80 research outputs found
Synchronizing Processes
In this monograph we develop a mathematical theory for a concurrent language based on angelic and demonic nondeterminism. An underlying model is defined with sets of sets of sequences of synchronization actions. A refinement relation is defined for the model, and equivalence classes under this relation are identified with processes. Processes, together with the refinement relation, form a complete distributive lattice. We define a language with parallel composition, sequential composition, angelic and demonic nondeterminism, and an operator that connects pairs of synchronization actions into synchronization statements and hides these actions from observation. Also, angelic and demonic iteration are defined. All operators are monotonic with respect to the refinement ordering. Many algebraic properties are proven from these definitions. We study duals of processes and prove that they can be related to the most demonic environment in which a process will not deadlock. We give a simple example to illustrate the use of duals. We study classes of programs for which angelic choice can be implemented by probing the environment for its next action. To this end specifications of processes are extended with simple conditions on the environment. We give a more elaborate example to illustrate the use of these conditions and the compositionality of the method. Finally we briefly introduce an operational model that describes implementable processes only. This model mentions probes explicitly. Such a model may form a basis for a language that is less restrictive than ours, but that will also have less attractive algebraic properties
Benchmarking Apache Arrow Flight -- A wire-speed protocol for data transfer, querying and microservices
Moving structured data between different big data frameworks and/or data
warehouses/storage systems often cause significant overhead. Most of the time
more than 80\% of the total time spent in accessing data is elapsed in
serialization/de-serialization step. Columnar data formats are gaining
popularity in both analytics and transactional databases. Apache Arrow, a
unified columnar in-memory data format promises to provide efficient data
storage, access, manipulation and transport. In addition, with the introduction
of the Arrow Flight communication capabilities, which is built on top of gRPC,
Arrow enables high performance data transfer over TCP networks. Arrow Flight
allows parallel Arrow RecordBatch transfer over networks in a platform and
language-independent way, and offers high performance, parallelism and security
based on open-source standards.
In this paper, we bring together some recently implemented use cases of Arrow
Flight with their benchmarking results. These use cases include bulk Arrow data
transfer, querying subsystems and Flight as a microservice integration into
different frameworks to show the throughput and scalability results of this
protocol. We show that Flight is able to achieve up to 6000 MB/s and 4800 MB/s
throughput for DoGet() and DoPut() operations respectively. On Mellanox
ConnectX-3 or Connect-IB interconnect nodes Flight can utilize upto 95\% of the
total available bandwidth. Flight is scalable and can use upto half of the
available system cores efficiently for a bidirectional communication. For query
systems like Dremio, Flight is order of magnitude faster than ODBC and turbodbc
protocols. Arrow Flight based implementation on Dremio performs 20x and 30x
better as compared to turbodbc and ODBC connections respectively
A Distributed Implementation of a Task Pool
In this paper we present a distributed algorithm to implement a task pool. The algorithm can be
used to implement a processor farm, i.e., a collection of processes that consume tasks from the task pool
and possibly produce tasks into it. There are no restrictions on which process consumes which task nor on
the order in which tasks are processed. The algorithm takes care of the distribution of the tasks over the
processes and ensures load balancing. We derive the algorithm by transforming a sequential algorithm
into a distributed one. The transformation is guided by the distribution of the data over processes. First
we discuss the case of two processes, and then the general case of one or more processes
Distributed Sorting
In this paper we present a distributed sorting algorithm, which is a variation on exchange sort, i.e.,
neighboring elements that are out of order are exchanged. We derive the algorithm by transforming a
sequential algorithm into a distributed one. The transformation is guided by the distribution of the data
over processes. First we discuss the case of two processes, and then the general case of one or more
processes. Finally we propose a more efficient solution for the general case
An Intermediate Representation for Composable Typed Streaming Dataflow Designs
Tydi is an open specification for streaming dataflow designs in digital
circuits, allowing designers to express how composite and variable-length data
structures are transferred over streams using clear, data-centric types. These
data types are extensively used in a many application domains, such as big data
and SQL applications. This way, Tydi provides a higher-level method for
defining interfaces between components as opposed to existing bit and
byte-based interface specifications. In this paper, we introduce an open-source
intermediate representation (IR) which allows for the declaration of Tydi's
types. The IR enables creating and connecting components with Tydi Streams as
interfaces, called Streamlets. It also lets backends for synthesis and
simulation retain high-level information, such as documentation. Types and
Streamlets can be easily reused between multiple projects, and Tydi's streams
and type hierarchy can be used to define interface contracts, which aid
collaboration when designing a larger system. The IR codifies the rules and
properties established in the Tydi specification and serves to complement
computation-oriented hardware design tools with a data-centric view on
interfaces. To support different backends and targets, the IR is focused on
expressing interfaces, and complements behavior described by hardware
description languages and other IRs. Additionally, a testing syntax for the
verification of inputs and outputs against abstract streams of data, and for
substituting interdependent components, is presented which allows for the
specification of behavior. To demonstrate this IR, we have created a grammar,
parser, and query system, and paired these with a backend targeting VHDL.Comment: arXiv admin note: substantial text overlap with arXiv:2212.1200
Tydi-lang: A Language for Typed Streaming Hardware
Transferring composite data structures with variable-length fields often
requires designing non-trivial protocols that are not compatible between
hardware designs. When each project designs its own data format and protocols
the ability to collaborate between hardware developers is diminished, which is
an issue especially in the open-source community. Because the high-level
meaning of a protocol is often lost in translation to low-level languages when
a custom protocol needs to be designed, extra documentation is required, the
interpretation of which introduces new opportunities for errors.
The Tydi specification (Tydi-spec) was proposed to address the above issues
by codifying the composite and variable-length data structures in a type and
providing a standard protocol to transfer typed data among hardware components.
The Tydi intermediate representation (Tydi-IR) extends the Tydi-spec by
defining typed interfaces, typed components, and connections among typed
components.
In this paper, we propose Tydi-lang, a high-level hardware description
language (HDL) for streaming designs. The language incorporates Tydi-spec to
describe typed streams and provides templates to describe abstract reusable
components. We also implement an open-source compiler from Tydi-lang to
Tydi-IR. We leverage a Tydi-IR to VHDL compiler, and also present a simulator
blueprint to identify streaming bottlenecks. We show several Tydi-lang examples
to translate high-level SQL to VHDL to demonstrate that Tydi-lang can
efficiently raise the level of abstraction and reduce design effort.Comment: 8 pages and 1 page of reference, 4 figures, 4 table
- …